package cn.disicn.controller;

import java.io.File;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jfinal.aop.Before;
import com.jfinal.aop.Clear;
import com.jfinal.core.ActionKey;
import com.jfinal.core.Controller;
import com.jfinal.ext.interceptor.POST;
import com.jfinal.kit.PropKit;
import com.jfinal.plugin.ehcache.CacheKit;
import com.jfinal.upload.UploadFile;

import cn.disicn.common.Const;
import cn.disicn.common.ServerResponse;
import cn.disicn.model.SecPublishUser;
import cn.disicn.service.SecPublishUserService;
import cn.disicn.util.EmailUtil;
import cn.disicn.util.FileUploadUtil;
import cn.disicn.util.IDUtil;
import cn.disicn.util.ImageUtil;
import cn.disicn.util.MD5Util;
import cn.disicn.util.SMSUtil;

/**
 * 
 * @author Luyao
 * @date 2017年11月24日 下午2:21:07
 * @desc:用户模块
 */
public class SecPublishUserController extends Controller {

	private static final Logger LOGGER = LoggerFactory.getLogger(SecPublishUserController.class);

	private static final SecPublishUserService USER_SERVICE = new SecPublishUserService();

	/**
	 * 
	 * @desc:用户登录
	 * @date 2017年11月24日 下午2:20:48
	 */
	@Clear
	@Before(POST.class)
	public void login() {
		// 获取登录的参数
		String account = getPara("account");
		String password = getPara("password");
		// 判断格式是否正确
		String regEmail = "([a-z0-9_\\.-]+)@([\\da-z\\.-]+)\\.([a-z\\.]{2,6})";
		String regPhone = "1[34578]\\d{9}";
		String regPwd = "(\\w){8,20}";
		if (!account.matches(regPhone) && !account.matches(regEmail)) {
			LOGGER.error("账号不合法");
			renderJson(ServerResponse.createByErrorMsg("用户不存在"));
		} else if (!password.matches(regPwd)) {
			renderJson(ServerResponse.createByErrorMsg("密码错误"));
		}

		// 判断登录类型
		String type = "";
		if (account.matches(regPhone)) {
			type = Const.loginType.PHONE;
		} else {
			type = Const.loginType.EMAIL;
		}

		// 查询账号是否存在及比对账号和密码
		ServerResponse<SecPublishUser> serverResponse = USER_SERVICE.login(account, password, type);
		if (serverResponse.isSuccess()) {
			LOGGER.info("登录成功");
			// 将用户信息存在session
			setSessionAttr(Const.userType.CURRENT_USER, serverResponse.getData());
		} else {
			LOGGER.error("登录失败");
		}
		renderJson(serverResponse);
	}

	/**
	 * 
	 * @desc:获取图片验证码图片二进制文件
	 * @date 2017年11月25日 下午4:57:42
	 */
	@Clear
	@ActionKey("/getImgCode")
	public void getPictureVerificationCode() {
		renderJson(ImageUtil.getGraphics());
	}

	/**
	 * 
	 * @desc:退出登录
	 * @date 2017年11月25日 下午7:07:37
	 */
	public void logoutLogin() {
		removeSessionAttr(Const.userType.CURRENT_USER);
		redirect("/login");
	}

	/**
	 * 用户注册
	 */
	@Clear
	@Before(POST.class)
	public void register() {
		// 获取参数
		String phone = getPara("phone");
		String password = getPara("password");
		// 判断格式是否正确
		String regPhone = "1[34578]\\d{9}";
		String regPwd = "(\\w){8,20}";
		// 判断
		if (phone.matches(regPhone) && password.matches(regPwd)) {
			SecPublishUser user = new SecPublishUser();
			// 添加id
			user.setId(IDUtil.getId());
			// 添加phone
			user.setPhone(phone);
			// MD5加密
			String md5pwd = MD5Util.MD5EncodeUtf8(password);
			// 添加密码
			user.setPassword(md5pwd);
			// 添加注册时间
			user.setCreateTime(new Date());
			renderJson(USER_SERVICE.register(user));
		} else {
			renderJson(ServerResponse.createByErrorMsg("注册信息有误"));
		}
	}

	/**
	 * 注册时判断用户是否存在
	 */
	@Clear
	public void checkAccount() {
		// 获取手机号
		String phone = getPara("account");
		// 获取手机号是否存在
		renderJson(USER_SERVICE.checkForExistence(phone, Const.loginType.PHONE));
	}

	/**
	 * 发送验证码
	 */
	@Clear
	public void sendSMS() {
		// 获取手机号
		String phone = getPara("account");
		if (phone == null) {
			// 获取session中的phone
			SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
			phone = user.getPhone();
		}
		if (phone != null) {
			try {
				// 调用发送验证码接口,返回发送的验证码
				String send = SMSUtil.getphone(phone);
				// 判断短信是否异常
				if (send == "error") {
					renderJson(ServerResponse.createByErrorMsg("您今日发送验证码过多，请明日再试"));
				} else {
					// 存储手机号和验证码
					CacheKit.put("SMSCode", phone, send);
					// 返回正确
					renderJson(ServerResponse.createBySuccessMsg("发送成功"));
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
				renderJson(ServerResponse.createByErrorMsg("稍后重试"));
			}
		} else {
			renderJson(ServerResponse.createByErrorMsg("稍后重试"));
		}
	}

	/**
	 * 对比验证码
	 */
	@Clear
	public void vail() {
		// 获取输入的验证码
		String code = getPara("code");
		// 获取手机号
		String phone = getPara("account");

		if (phone == null) {
			// 获取session中的phone
			SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
			phone = user.getPhone();
		}

		// 获取缓存中的验证码
		String yzm = CacheKit.get("SMSCode", phone);

		if (yzm != null && code.equals(yzm)) {
			renderJson(ServerResponse.createBySuccess());
		} else {
			renderJson(ServerResponse.createByErrorMsg("短信验证码错误"));
		}
	}

	/**
	 * 判断原密码
	 */
	public void vailOldPwd() {
		// 获取原密码
		String password = getPara("pwd");
		// 判断密码是否为空
		if (!StringUtils.isBlank(password)) {
			renderJson(ServerResponse.createByErrorMsg("密码不能为空"));
		}
		// 获取session中的用户名
		SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
		// 判断用户的密码是否正确
		renderJson(USER_SERVICE.login(user.getPhone(), password, Const.loginType.PHONE));
	}

	/**
	 * 修改密码
	 */
	public void changePwd() {
		// 获取密码
		String password = getPara("pwd");
		// 获取session中的用户名
		SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
		// 将密码进行md5加密，并添加到user中
		String pwd = MD5Util.MD5EncodeUtf8(password);
		user.setPassword(pwd);
		// 修改密码
		renderJson(USER_SERVICE.changePassword(user));
	}

	/**
	 * 头像上传
	 */
	public void userImgUpload() {
		// 获取文件
		UploadFile file = getFile();
		if (file != null) {
			// 创建文件对象
			File f = file.getFile();
			// 上传到oss中
			String url = FileUploadUtil.fileUpload(f, PropKit.use("ossgon.properties").get("userHead")).getData();
			// 删除头像
			f.delete();
			// 返回头像
			if (!StringUtils.isBlank(url)) {
				// 在session中获取用户的账号
				SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
				// 获取原头像
				String oldHeadImg = user.getHeadImgUrl();
				// 将头像存入数据库中
				user.setHeadImgUrl(url);
				if (USER_SERVICE.uploadHeadImage(user).isSuccess()) {
					// 修改session头像地址
					user.setHeadImgUrl(url);
					setSessionAttr(Const.userType.CURRENT_USER, user);
					//判断是否可删除
					if (!StringUtils.isBlank(oldHeadImg)) {
						// 删除原头像
						String fileName = oldHeadImg.substring(
								oldHeadImg.indexOf(PropKit.use("ossgon.properties").get("userHead")), oldHeadImg.length());
						FileUploadUtil.delFile(fileName).getStatus();
					}
					renderJson(ServerResponse.createBySuccess(url));
				} else {
					renderJson(ServerResponse.createByErrorMsg("上传失败"));
				}
			}
		} else {
			renderJson(ServerResponse.createByErrorMsg("没有找到文件"));
		}
	}

	/**
	 * 修改用户名
	 */
	public void changeName() {
		// 获取username
		String name = getPara("name");
		// 判断用户名是否为空
		if (StringUtils.isBlank(name)) {
			renderJson(ServerResponse.createByErrorMsg("用户名为空"));
		}
		// 在session中获取用户的账号
		SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
		user.setUserName(name);
		// 修改用户名
		ServerResponse<String> serverResponse = USER_SERVICE.updUserName(user);
		if (serverResponse.isSuccess()) {
			setSessionAttr(Const.userType.CURRENT_USER, user);
		}
		renderJson(serverResponse);
	}

	/**
	 * 修改绑定的手机号
	 */
	public void changePhone() {
		// 获取绑定的手机号
		String phone = getPara("phone");
		// 获取session中的原手机号
		SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
		// 获取账号
		String oldPhone = user.getPhone();
		// 判断手机号是否为空
		if (StringUtils.isBlank(phone)) {
			renderJson(ServerResponse.createByErrorMsg("手机号不能为空"));
		}
		ServerResponse<String> serverResponse = USER_SERVICE.changePhone(oldPhone, phone);
		if (serverResponse.isSuccess()) {
			user.setPhone(phone);
			setSessionAttr(Const.userType.CURRENT_USER, user);
		}
		renderJson(serverResponse);
	}

	/**
	 * 绑定新手机号和发送的验证码
	 */
	public void newPhoneSendSMS() {
		// 获取手机号
		String phone = getPara("account");
		if (StringUtils.isBlank(phone)) {
			renderJson(ServerResponse.createByErrorMsg("手机号为空"));
		}
		// 获取session中的phone
		SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
		String oldphone = user.getPhone();

		// 判断绑定的新手机号是否与旧手机号相同
		if (phone.equals(oldphone)) {
			renderJson(ServerResponse.createByErrorMsg("新手机号不能与旧手机号相同"));
		} else {
			// 判断新手机号是否已存在
			if (USER_SERVICE.checkForExistence(phone, Const.loginType.PHONE).isSuccess()) {
				renderJson(ServerResponse.createByErrorMsg("该手机号已被绑定"));
			} else {
				try {
					// 调用发送验证码接口,返回发送的验证码
					String send = SMSUtil.getphone(phone);
					// 判断短信是否异常
					if (send == "error") {
						renderJson(ServerResponse.createByErrorMsg("今天短信条数已用完"));
					} else {
						// 存储手机号和验证码
						CacheKit.put("SMSCode", phone, send);
						// 返回正确
						renderJson(ServerResponse.createBySuccess());
					}
				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
					renderJson(ServerResponse.createByErrorMsg("稍后重试"));
				}
			}
		}
	}

	/**
	 * 上传身份证正面图片
	 */
	public void idFrontUpload() {
		// 获取file对象
		File file = getFile().getFile();
		// 判断file对象是否为空
		if (file != null) {
			// 上传到oss服务器
			String url = FileUploadUtil.fileUpload(file, PropKit.use("ossgon.properties").get("idCard")).getData();
			// 删除图片
			file.delete();
			// 判断是否上传成功
			if (url != null) {
				// 返回成功结果
				renderJson(ServerResponse.createBySuccess(url));
			} else {
				// 返回失败
				renderJson(ServerResponse.createByErrorMsg("上传失败"));
			}
		} else {
			renderJson(ServerResponse.createByErrorMsg("没有文件"));
		}
	}

	/**
	 * 上传身份证反面图片
	 */
	public void idBackUpload() {
		// 获取file对象
		File file = getFile().getFile();
		// 判断file对象是否为空
		if (file != null) {
			// 上传到oss服务器
			String url = FileUploadUtil.fileUpload(file, PropKit.use("ossgon.properties").get("idCard")).getData();
			// 删除图片
			file.delete();
			// 判断是否上传成功
			if (url != null) {
				// 返回成功结果
				renderJson(ServerResponse.createBySuccess(url));
			} else {
				// 返回失败
				renderJson(ServerResponse.createByErrorMsg("上传失败"));
			}
		} else {
			renderJson(ServerResponse.createByErrorMsg("没有文件"));
		}
	}

	/**
	 * 上传企业营业执照图片
	 */
	public void attachmentUpload() {
		// 获取file对象
		File file = getFile().getFile();
		// 判断file对象是否为空
		if (file != null) {
			// 上传到oss服务器
			String url = FileUploadUtil.fileUpload(file, PropKit.use("ossgon.properties").get("businessLicense"))
					.getData();
			// 删除图片
			file.delete();
			// 判断是否上传成功
			if (url != null) {
				// 返回成功结果
				renderJson(ServerResponse.createBySuccess(url));
			} else {
				// 返回失败
				renderJson(ServerResponse.createByErrorMsg("上传失败"));
			}
		} else {
			renderJson(ServerResponse.createByErrorMsg("没有文件"));
		}
	}

	/**
	 * 身份认证
	 */
	public void authSave() {
		SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
		if (Integer.parseInt(user.getStatus()) == Const.userStatusEnum.AUTHENTICATED.getCode()) {
			renderJson(ServerResponse.createByErrorMsg("您已完成认证"));
		}
		// 获取验证的type
		Integer type = getParaToInt("type");
		if (type == null) {
			renderJson(ServerResponse.createByErrorMsg("参数为空"));
		}
		// 判断type验证
		if (type == 0) {
			// 个人验证
			// 获取真实姓名
			String realName = getPara("realName");
			// 获取身份证号码
			String idCard = getPara("idCard");
			// 获取身份证正面
			String idCardFrontImgUrl = getPara("idCardFrontImgUrl");
			// 获取身份证反面
			String idCardBackImgUrl = getPara("idCardBackImgUrl");
			// 获取session中的对象
			user.setRealName(realName);
			user.setIdCardFrontImgUrl(idCardFrontImgUrl);
			user.setIdCardBackImgUrl(idCardBackImgUrl);
			user.setIdCardNumber(idCard);
			// 添加认证
			ServerResponse<String> serverResponse = USER_SERVICE.personal(user);
			if (serverResponse.isSuccess()) {
				if (USER_SERVICE.findSecUserByPhone(user.getPhone()).isSuccess()) {
					SecPublishUser secuser = (SecPublishUser) USER_SERVICE.findSecUserByPhone(user.getPhone()).getData();
					setSessionAttr(Const.userType.CURRENT_USER, secuser);
				}
				renderJson(serverResponse);
			}
			renderJson(serverResponse);
		} else if (type == 1) {
			// 企业验证
			// 获取真实姓名
			String realName = getPara("realName");
			// 获取身份证号码
			String idCard = getPara("idCard");
			// 获取公司名称
			String companyName = getPara("companyName");
			// 获取企业营业执照
			String attachmentUrl = getPara("attachmentUrl");
			// 获取session中的对象
			user.setRealName(realName);
			user.setCorporateName(companyName);
			user.setAttachmentUrl(attachmentUrl);
			user.setIdCardNumber(idCard);

			// 获取身份证图片的url
			List<String> idcardimg = USER_SERVICE.idCardImage(user.getPhone());
			// 添加认证
			ServerResponse<String> serverResponse = USER_SERVICE.company(user);
			if (serverResponse.isSuccess()) {
				// 删除img
				if (idcardimg != null) {
					for (String str : idcardimg) {
						
						FileUploadUtil.delFile(str
								.substring(str.indexOf(PropKit.use("ossgon.properties").get("idCard")), str.length()));
						System.out.println("成功"+str);
					}
				}
				// 给session重新赋值
				if (USER_SERVICE.findSecUserByPhone(user.getPhone()).isSuccess()) {
					SecPublishUser secuser = (SecPublishUser) USER_SERVICE.findSecUserByPhone(user.getPhone()).getData();
					setSessionAttr(Const.userType.CURRENT_USER, secuser);
				}
				renderJson(serverResponse);
			}
			renderJson(serverResponse);
		}
	}

	/**
	 * 发送邮箱验证码
	 */
	public void sendEmail() {
		// 获取发送邮件的账号
		String email = getPara("account");
		if (email != null) {
			// 判断邮箱是否已绑定
			if (USER_SERVICE.checkForExistence(email, Const.loginType.EMAIL).isSuccess()) {
				renderJson(ServerResponse.createByErrorMsg("邮箱账号已被绑定"));
			}
			try {
				// 发送邮件
				Integer code = EmailUtil.sendEmail(email, null);
				// 将core存入session中
				setSessionAttr(email, code);
				// 返回成功
				renderJson(ServerResponse.createBySuccess());
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} else {
			renderJson(ServerResponse.createByErrorMsg("参数为空"));
		}
	}

	/**
	 * 验证邮箱验证码是否正确
	 */
	public void vailEmail() {
		// 获取邮箱验证码
		String code = getPara("code");
		// 获取邮箱账号
		String email = getPara("email");
		// 判断邮箱验证码是否为空
		if (code != null) {
			// 获取session中的邮箱验证码
			String yzm = getSessionAttr(email).toString();
			// 判断邮箱验证码是否正确
			if (yzm != null && code.equals(yzm)) {
				// 删除session中的验证码
				removeSessionAttr(email);
				// 返回成功
				renderJson(ServerResponse.createBySuccess());
			} else {
				// 返回失败
				renderJson(ServerResponse.createByErrorMsg("邮箱验证码错误"));
			}
		} else {
			renderJson(ServerResponse.createByErrorMsg("邮箱验证码为空"));
		}
	}

	/**
	 * 修改邮箱账号
	 */
	public void changeEmail() {
		// 获取邮箱账号
		String email = getPara("email");
		// 判断邮箱账号是否为空
		if (StringUtils.isBlank(email)) {
			renderJson(ServerResponse.createByErrorMsg("参数为空"));
		}
		// 从session中取用户账号
		SecPublishUser user = (SecPublishUser) getSessionAttr(Const.userType.CURRENT_USER);
		// 保存邮箱账号
		ServerResponse<String> serverResponse = USER_SERVICE.changeEmail(user.getPhone(), email);
		if (serverResponse.isSuccess()) {
			user.setEmail(email);
			setSessionAttr(Const.userType.CURRENT_USER, user);
		}
		renderJson(serverResponse);
	}

	/**
	 * 清除session
	 */
	public void delSecUser(){
		//清除session
		getSession().removeAttribute("secuser");
		//返回页面
		renderJson(ServerResponse.createBySuccess());
	}
}
